Deprecate passing bare coroutine and generator functions to param.rx - #1227

Description

param.rx treats functions inconsistently. A plain function passed to rx(fn) is wrapped as a value you can call or pipe, but a coroutine, generator or async generator function is called and its result resolved. The same split shows up in operation arguments: rx(x).rx.pipe(f, afunc), rx([1]) + [afunc], rx.where(afunc, ...) and expr.rx.value = afunc all call a bare async function while passing a sync one through untouched. For an API whose job is to wrap values this is surprising, and resolving outside a running event loop leads to errors like "coroutine was never awaited".

This PR starts moving rx to a single rule, where every function is a value unless it is explicitly declared a reference with param.bind or param.depends:

• Zero-argument coroutine and generator functions are still resolved, but now emit a ParamFutureWarning telling users to wrap them with param.bind(fn), which keeps today's behavior. In a future release rx will keep them as values.
• Coroutine and generator functions that require arguments are kept as values right away, without a warning. Resolving them always failed with a TypeError, so nothing that works today changes. Arguments bound by a partial count as supplied, and so do defaults, so a function with only defaulted arguments still falls under the deprecation.

import param

async def fetch():
    return 1

async def fetch_url(url):
    ...

param.rx(fetch)                            # ParamFutureWarning: ... Wrap it with param.bind(fetch) to keep resolving it.
param.rx(param.bind(fetch))                # no warning, resolved as before
param.rx(fetch_url).rx.value is fetch_url  # previously TypeError: missing 1 required positional argument

Both rules apply wherever rx resolves a value: rx(fn), operation arguments (including ones nested in lists, tuples, dicts and slices), where branches, collect, rx.value assignments and .rx.overrides. The warning fires once, when the expression or operation is built, not on every re-evaluation.

The warning's advice depends on the entry point. Only rx(fn) actually resolves the function, so only there does the message suggest param.bind(fn) (or param.bind(fn, ...) for a partial). Everywhere else the function is called but its coroutine or async generator is passed on without ever being awaited or iterated, so the message says so and that the function itself will be passed on in future. Functions inside a set are never resolved and don't warn.

Calling an async function held by rx

Once bare async functions are kept as values, the natural way to call one reactively is rx(afunc)(x). Until now that produced an unawaited coroutine, because a call operation is stored as '__call__' and never qualified as async. Calling an expression whose value is a coroutine, generator or async generator function, or an async method of the wrapped object, now awaits or iterates the result exactly like .rx.pipe(afunc, x), including .rx.awaiting and re-resolving when inputs change:

number = param.rx(1)
param.rx(fetch_url)(number)       # resolves to the awaited result
param.rx(client).fetch(number)    # same for async methods

rx(afunc)(x) previously raised a TypeError, so nothing relied on it. rx(obj).amethod(x) previously returned the coroutine object. Whether a call is async is decided from the callee when the call is created, so swapping the held function between a sync and an async one via rx.value keeps the original mode, and a callee coming out of an upstream async node that hasn't resolved yet isn't detected.

Parameters are unchanged

Parameters with allow_refs=True keep resolving bare coroutine and generator functions, without a warning, and still raise when such a function requires arguments, so a forgotten bind fails loudly. Resolving references is the point of allow_refs, and streaming a generator into a parameter is a documented feature that Panel relies on, e.g. pn.pane.Markdown(object=gen) and the refs= argument. An earlier version of this PR that also warned on parameters would have affected three Panel docs pages and Panel's own refs= code path, and broke one Panel unit test. Nothing in Panel's docs, tests or internals passes a bare async function to rx, so this version needs no Panel changes.

One related fix does touch parameters: those that are implicitly allow_refs=False no longer speculatively resolve a bare coroutine or generator function just to check whether to warn about a reference. That speculative resolve started a coroutine nobody awaited, and it could eventually overwrite the parameter's value with the result.

Tests and docs

The existing rx tests and the rx example in the Generators user guide now use param.bind(...), and the .rx.awaiting section of the Reactive Expressions guide shows calling an async function and an async method. New tests in tests/testrefs.py cover, for coroutine, async generator, generator and partial functions:

• the warning for every rx entry point, its message per entry point, and that it fires only once
• that bound functions don't warn, and that functions in a set don't either
• that functions requiring arguments are kept as values in every entry point, including rx.value on a root built from an async function, while defaults-only functions are still resolved
• that an async function whose annotations can't be evaluated (e.g. TYPE_CHECKING-only imports on Python 3.14+) still works
• that parameters keep resolving silently, still raise for functions requiring arguments, and leave the value alone when refs are implicitly disabled

New tests in tests/testreactive.py cover calling async, async generator and generator functions and async methods through rx.

The full Param test suite passes locally on Python 3.11 and 3.14. Against this branch, Panel's test_reactive, pane and layout suites pass, and of the common Panel patterns only pn.rx(fn) warns.

AI Disclosure

Tool & Model: Claude Code + Claude Opus 5.5
Usage: Investigated the reference resolution code paths, implemented the warning, the handling of functions requiring arguments and awaiting async calls, addressed review findings, updated tests and docs, and measured the impact on Panel's docs and test suite.

• I have tested all AI-generated content in my PR.
• I take responsibility for all AI-generated content in my PR.

Checklist

• Tests added and are passing
• Added documentation